/**
 * 计划生成器 (PlanGenerator)
 * 
 * 为检测到的任务生成执行计划
 * Requirements: 4.2, 4.3, 4.4, 4.5
 */

import type { DetectedTask, TaskPlan, PlanStep, ApiChatMessage } from '../types';
import { GitCodeApiService, defaultApiService } from './GitCodeApiService';

/**
 * 计划生成器接口
 */
export interface IPlanGenerator {
  generate(task: DetectedTask): Promise<TaskPlan>;
  format(plan: TaskPlan): string;
}

/**
 * LLM 返回的计划结构
 */
interface LLMPlanResponse {
  title: string;
  summary: string;
  steps: Array<{
    order: number;
    description: string;
    assignee?: string;
    estimatedTime?: string;
    deadline?: string;
  }>;
}

/**
 * 计划生成器实现
 */
export class PlanGenerator implements IPlanGenerator {
  private apiService: GitCodeApiService;

  constructor(apiService: GitCodeApiService = defaultApiService) {
    this.apiService = apiService;
  }

  /**
   * 为任务生成执行计划
   * 
   * @param task - 检测到的任务
   * @returns 生成的任务计划
   * Requirements: 4.2, 4.3, 4.4, 4.5
   */
  async generate(task: DetectedTask): Promise<TaskPlan> {
    try {
      const prompt = this.buildPlanPrompt(task);
      const messages: ApiChatMessage[] = [
        {
          role: 'system',
          content: this.getSystemPrompt(),
        },
        {
          role: 'user',
          content: prompt,
        },
      ];

      const response = await this.apiService.chat(messages);
      return this.parsePlanResponse(response, task);
    } catch {
      // 发生错误时返回基础计划
      return this.createFallbackPlan(task);
    }
  }

  /**
   * 格式化计划为可读文本
   * 
   * @param plan - 任务计划
   * @returns 格式化的文本
   */
  format(plan: TaskPlan): string {
    return plan.shareableText;
  }

  /**
   * 构建计划生成提示词
   */
  private buildPlanPrompt(task: DetectedTask): string {
    let prompt = `请为以下任务生成详细的执行计划：

任务描述：${task.description}
参与者：${task.participants.join(', ')}
优先级：${task.priority}`;

    if (task.deadline) {
      prompt += `\n截止时间：${task.deadline.toISOString()}`;
    }

    prompt += `

请生成：
1. 计划标题
2. 计划摘要
3. 具体执行步骤（包含负责人分配和时间估算）`;

    return prompt;
  }

  /**
   * 获取系统提示词
   */
  private getSystemPrompt(): string {
    return `你是一个任务计划助手。你的任务是为给定的任务生成详细的执行计划。

请以 JSON 格式返回结果，格式如下：
{
  "title": "计划标题",
  "summary": "计划摘要",
  "steps": [
    {
      "order": 1,
      "description": "步骤描述",
      "assignee": "负责人（如果有多个参与者）",
      "estimatedTime": "预估时间（如：30分钟、1小时）",
      "deadline": "截止时间（ISO格式，如果有的话）"
    }
  ]
}

规则：
1. 只返回 JSON，不要添加其他文字
2. 步骤要具体、可执行
3. 如果任务有多个参与者，为每个步骤分配负责人
4. 如果任务有截止时间，在步骤中包含时间节点
5. 步骤数量根据任务复杂度决定，通常 3-7 步
6. 预估时间要合理`;
  }

  /**
   * 解析 LLM 返回的计划响应
   */
  private parsePlanResponse(response: string, task: DetectedTask): TaskPlan {
    try {
      // 尝试提取 JSON 内容
      const jsonMatch = response.match(/\{[\s\S]*\}/);
      if (!jsonMatch) {
        return this.createFallbackPlan(task);
      }

      const parsed: LLMPlanResponse = JSON.parse(jsonMatch[0]);
      
      // 验证必要字段
      if (!parsed.steps || !Array.isArray(parsed.steps) || parsed.steps.length === 0) {
        return this.createFallbackPlan(task);
      }

      const steps = this.convertSteps(parsed.steps, task);
      const plan: TaskPlan = {
        taskId: task.id,
        title: parsed.title || task.description,
        steps,
        summary: parsed.summary || `${task.description} 的执行计划`,
        shareableText: '',
      };

      // 生成可分享文本
      plan.shareableText = this.generateShareableText(plan, task);

      return plan;
    } catch {
      return this.createFallbackPlan(task);
    }
  }

  /**
   * 转换步骤数据
   */
  private convertSteps(
    rawSteps: LLMPlanResponse['steps'],
    task: DetectedTask
  ): PlanStep[] {
    return rawSteps.map((step, index) => {
      const planStep: PlanStep = {
        order: step.order || index + 1,
        description: step.description || `步骤 ${index + 1}`,
      };

      // 如果任务有多个参与者，添加负责人
      // Requirements: 4.3
      if (task.participants.length > 1 && step.assignee) {
        planStep.assignee = step.assignee;
      }

      // 添加预估时间
      if (step.estimatedTime) {
        planStep.estimatedTime = step.estimatedTime;
      }

      // 如果任务有截止时间，添加时间节点
      // Requirements: 4.4
      if (step.deadline) {
        const parsedDate = new Date(step.deadline);
        if (!isNaN(parsedDate.getTime())) {
          planStep.deadline = parsedDate;
        }
      } else if (task.deadline && index === rawSteps.length - 1) {
        // 最后一步使用任务截止时间
        planStep.deadline = task.deadline;
      }

      return planStep;
    });
  }

  /**
   * 生成可分享的文本版本
   * Requirements: 4.5
   */
  private generateShareableText(plan: TaskPlan, task: DetectedTask): string {
    let text = `📋 ${plan.title}\n\n`;
    text += `📝 ${plan.summary}\n\n`;
    text += `👥 参与者：${task.participants.join('、')}\n`;
    
    if (task.deadline) {
      text += `⏰ 截止时间：${this.formatDate(task.deadline)}\n`;
    }
    
    text += `\n📌 执行步骤：\n`;
    
    for (const step of plan.steps) {
      text += `${step.order}. ${step.description}`;
      
      if (step.assignee) {
        text += ` (@${step.assignee})`;
      }
      
      if (step.estimatedTime) {
        text += ` [${step.estimatedTime}]`;
      }
      
      if (step.deadline) {
        text += ` 截止：${this.formatDate(step.deadline)}`;
      }
      
      text += '\n';
    }

    return text;
  }

  /**
   * 格式化日期
   */
  private formatDate(date: Date): string {
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    const hours = String(date.getHours()).padStart(2, '0');
    const minutes = String(date.getMinutes()).padStart(2, '0');
    
    return `${year}-${month}-${day} ${hours}:${minutes}`;
  }

  /**
   * 创建备用计划（当 LLM 调用失败时）
   */
  private createFallbackPlan(task: DetectedTask): TaskPlan {
    const steps: PlanStep[] = [
      {
        order: 1,
        description: '确认任务要求和目标',
        estimatedTime: '10分钟',
      },
      {
        order: 2,
        description: task.description,
        estimatedTime: '待定',
      },
      {
        order: 3,
        description: '完成并确认结果',
        estimatedTime: '10分钟',
      },
    ];

    // 如果有多个参与者，分配负责人
    // Requirements: 4.3
    if (task.participants.length > 1) {
      steps[0].assignee = task.participants[0];
      steps[1].assignee = task.participants.length > 1 ? task.participants[1] : task.participants[0];
      steps[2].assignee = task.participants[0];
    }

    // 如果有截止时间，添加到最后一步
    // Requirements: 4.4
    if (task.deadline) {
      steps[steps.length - 1].deadline = task.deadline;
    }

    const plan: TaskPlan = {
      taskId: task.id,
      title: task.description,
      steps,
      summary: `${task.description} 的基础执行计划`,
      shareableText: '',
    };

    plan.shareableText = this.generateShareableText(plan, task);

    return plan;
  }
}

/**
 * 默认计划生成器实例
 */
export const planGenerator = new PlanGenerator();
